home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / PRGMANIA / QEDSRC / MAKRO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-12-29  |  12.0 KB  |  578 lines
  1. #include "global.h"
  2. #include "clipbrd.h"
  3. #include "desktop.h"
  4. #include "icon.h"
  5. #include "memory.h"
  6. #include "menu.h"
  7. #include "obj.h"
  8. #include "rsc.h"
  9. #include "scroll.h"
  10. #include "text.h"
  11. #include "windows.h"
  12. #include "makro.h"
  13.  
  14. /* exportierte Variablen ************************************************/
  15. BOOLEAN    makro_play, makro_rec;
  16.  
  17.  
  18. /*======================================================================*/
  19.  
  20. #define MAKRO_MAX         20                /* Makro Anzahl */
  21. #define MAKRO_PLAY_LEN 100                /* Makrolen expanded */
  22. #define MAKRO_DEF_LEN  100                /* einzelne Makrolänge */
  23.  
  24. #define UNUSED    0                            /* Werte für mode */
  25. #define TASTEN    1
  26. #define BLOCK    2
  27.  
  28. /*======================================================================*/
  29.  
  30. typedef struct{
  31.             WORD    scan;
  32.             WORD    ascii;
  33.             UWORD    nk;        /* normalized key */
  34. } T_KEY;
  35.  
  36. typedef struct {
  37.             BOOLEAN    mode;
  38.             WORD        len;
  39.             WORD        key;            /* F1 .. F20 */
  40.             UBYTE        name[10];
  41.             union
  42.             {
  43.                 T_KEY puffer[MAKRO_DEF_LEN];
  44.                 RING    text;
  45.             } daten;
  46. } T_MAKRO;
  47.  
  48. /*======================================================================*/
  49.  
  50. LOCAL T_KEY        makro_puffer[MAKRO_PLAY_LEN],
  51.                     *makro_ptr, *makro_end;
  52. LOCAL T_MAKRO     makro_list[MAKRO_MAX],
  53.                     *makro_rec_ptr,
  54.                     *makro_play_ptr;
  55. LOCAL WORD        makro_play_counter;
  56.  
  57. /*======================================================================*/
  58.  
  59. LOCAL VOID t_key2mk(CONST T_KEY *t_key, MKINFO *mk)
  60. {
  61.     mk->kreturn        = t_key->nk;
  62.     mk->ascii_code    = t_key->ascii;
  63.     mk->scan_code    = t_key->scan;
  64.     mk->shift        = (t_key->nk & NKF_SHIFT) != 0;
  65.     mk->ctrl            = (t_key->nk & NKF_CTRL) != 0;
  66.     mk->alt            = (t_key->nk & NKF_ALT) != 0;
  67. }
  68.  
  69. LOCAL VOID mk2t_key(CONST MKINFO *mk, T_KEY *t_key)
  70. {
  71.     t_key->scan        = mk->scan_code;
  72.     t_key->ascii    = mk->ascii_code;
  73.     t_key->nk        = mk->kreturn;
  74. }
  75.  
  76. VOID set_makro_str(UBYTE *ptr)
  77. {
  78.     WORD        l, i, v;
  79.     UBYTE        *p, name[10];
  80.     T_MAKRO    *m;
  81.  
  82.     p = strchr(ptr,'@');
  83.     if (!p)
  84.         return;
  85.     *p = EOS;
  86.     *(UBYTE*)COPYB(name,ptr,8) = EOS;
  87.     ptr = p+1;
  88.     p = strchr(ptr,'@');
  89.     if (!p)
  90.         return;
  91.     *p = EOS;
  92.     v = atoi(ptr);
  93.     ptr = p+1;
  94.     for (i=MAKRO_MAX,m=makro_list; (--i)>=0; m++)        /* Eintrag suchen */
  95.     {
  96.         if (m->key == v)                                                /* Alten Eintrag erweitern */
  97.             break;
  98.     }
  99.     if (i<0)
  100.         for (i=MAKRO_MAX,m=makro_list; (--i)>=0; m++)    /* Eintrag suchen */
  101.         {
  102.             if (m->mode==UNUSED)                                    /* Leerer Eintrag */
  103.             {
  104.                 strcpy(m->name,name);
  105.                 m->key = v;
  106.                 m->len = 0;
  107.                 m->mode = TASTEN;
  108.                 if (v==-1)
  109.                     makro_rec_ptr = m;
  110.                 else
  111.                     set_fkey(v, name);
  112.                 break;
  113.             }
  114.         }
  115.     if (i>=0)
  116.     {
  117.         l = m->len;
  118.         while((p = strchr(ptr,'@')) != NULL)
  119.         {
  120.             *p = EOS;
  121.             m->daten.puffer[l].nk = atoi(ptr);
  122.             ptr = p+1;
  123.             p = strchr(ptr,'@');
  124.             if (p)
  125.                 *p = EOS;
  126.             v = atoi(ptr);
  127.             m->daten.puffer[l].scan = (UBYTE)(v>>8);
  128.             m->daten.puffer[l].ascii = (UBYTE)v;
  129.             l++;
  130.             if (!p)
  131.                 break;
  132.             ptr = p+1;
  133.         }
  134.         m->len = l;
  135.     }
  136. }
  137.  
  138. BOOLEAN get_makro_str(WORD *nr, UBYTE *ptr)
  139. {
  140.     LOCAL WORD break_j;
  141.     UBYTE    s[20];
  142.     WORD    end, i, j = 0;
  143.  
  144.     if (*nr==-1)
  145.     {
  146.         break_j = 0;
  147.         *nr = 0;
  148.     }
  149.     for (i=MAKRO_MAX; (--i) >= 0; )
  150.         if (makro_list[i].mode == TASTEN)        /* nur Tasten-Makros */
  151.         {
  152.             if (*nr==j)
  153.                 break;
  154.             j++;
  155.         }
  156.     if (i>=0)                                /* Makro existiert */
  157.     {
  158.         ptr = COPYB(ptr, makro_list[i].name, (short) strlen(makro_list[i].name));        /* Name */
  159.         *ptr++ = '@';
  160.         itoa(makro_list[i].key, s, 10);
  161.         ptr = COPYB(ptr, s, (short) strlen(s));                                        /* Key */
  162.         j = break_j;
  163.         if (j + 8 < makro_list[i].len)
  164.             end = j+8;
  165.         else
  166.             end = makro_list[i].len;
  167.         for ( ; j<end; j++)
  168.         {
  169.             *ptr++ = '@';
  170.             itoa(makro_list[i].daten.puffer[j].nk, s, 10);
  171.             ptr = COPYB(ptr, s, (short) strlen(s));
  172.             *ptr++ = '@';
  173.             itoa((makro_list[i].daten.puffer[j].scan << 8) + makro_list[i].daten.puffer[j].ascii, s, 10);
  174.             ptr = COPYB(ptr, s, (short) strlen(s));
  175.         }
  176.         *ptr = EOS;
  177.         if (j<makro_list[i].len)
  178.         {
  179.             break_j = j;
  180.         }
  181.         else
  182.         {
  183.             break_j = 0;
  184.             (*nr)++;
  185.         }
  186.         return TRUE;
  187.     }
  188.     return FALSE;
  189. }
  190.  
  191. VOID del_makro(WORD key)
  192. {
  193.     T_MAKRO    *m;
  194.     WORD        i;
  195.  
  196.     m = makro_list;
  197.     for (i=MAKRO_MAX; (--i)>=0; m++)
  198.         if (m->mode != UNUSED && m->key == key)
  199.         {
  200.             if (makro_rec_ptr!=NULL && makro_rec_ptr==m)
  201.             {
  202.                 m->key = -1;
  203.             }
  204.             else
  205.             {
  206.                 if (m->mode==BLOCK)
  207.                     kill_textring(&m->daten.text);
  208.                 m->mode = UNUSED;
  209.             }
  210.             set_fkey(key,"");
  211.             draw_fkey(key, FALSE);
  212.             break;
  213.         }
  214. }
  215.  
  216. VOID get_makro_name(WORD scan, UBYTE *name)
  217. {
  218.     WORD        i;
  219.     T_MAKRO    *m;
  220.  
  221.     *name = EOS;
  222.     m = makro_list;
  223.     for (i=MAKRO_MAX; (--i)>=0; m++)
  224.         if (m->mode!=UNUSED && m->key == scan)
  225.         {
  226.             strcpy(name, m->name);
  227.             break;
  228.         }
  229. }
  230.  
  231. BOOLEAN pre_makro(MKINFO *mk)
  232. {
  233.     if (makro_play)                                /* Macro abspielen */
  234.     {
  235. retry:
  236.         if (makro_ptr < makro_end)
  237.         {
  238.             t_key2mk(makro_ptr, mk);
  239.             makro_ptr++;
  240.             return TRUE;
  241.         }
  242.         else                                            /* Abspielen beenden */
  243.         {
  244.             if (makro_play_counter > 1)
  245.             {
  246.                 makro_play = FALSE;
  247.                 start_play(makro_play_ptr->key, makro_play_counter-1);
  248.                 goto retry;
  249.             }
  250.             else
  251.                 end_play();
  252.         }
  253.     }
  254.     return FALSE;
  255. }
  256.  
  257. VOID post_makro(MKINFO *mk)
  258. {
  259.     if (makro_rec && !makro_play)                /* Zeichen erfassen */
  260.                                                         /* wenn echtes Zeichen */
  261.     {
  262.         WORD pos = makro_rec_ptr->len;
  263.         if (pos < MAKRO_DEF_LEN)
  264.         {
  265.             mk2t_key(mk, &(makro_rec_ptr->daten.puffer[pos]));
  266.             makro_rec_ptr->len++;
  267.         }
  268.         else
  269.             mybeep();
  270.     }
  271. }
  272.  
  273. VOID start_blk_rec(UBYTE *name, WORD key, RINGPTR r)
  274. {
  275.     WORD        new, i;
  276.     T_MAKRO    *m;
  277.  
  278.     new = -1;
  279.     m = makro_list;
  280.     for (i=0; i<MAKRO_MAX; i++,m++)            /* Eintrag suchen */
  281.     {
  282.         if (m->mode==UNUSED)                        /* Leerer Eintrag */
  283.             new = i;
  284.         else if (m->key == key)                    /* Alten Eintrag überschreiben */
  285.         {
  286.             new = i;
  287.             break;
  288.         }
  289.     }
  290.     if (new >- 1)
  291.     {
  292.         m = makro_list+new;
  293.         if (m->mode == BLOCK)
  294.             free_textring(&m->daten.text);
  295.         else
  296.             init_textring(&m->daten.text);
  297.         m->len = 0;                                /* leeren */
  298.         m->mode = BLOCK;
  299.         m->key = key;
  300.         doppeln(r,&m->daten.text);
  301.         strcpy(m->name,name);
  302.         set_fkey(key,name);
  303.         draw_fkey(key,FALSE);
  304.     }
  305. }
  306.  
  307. VOID start_rec(VOID)
  308. {
  309.     WORD        new, i;
  310.     T_MAKRO    *m;
  311.  
  312.     if (makro_rec_ptr!=NULL)
  313.     {
  314.         m = makro_rec_ptr;
  315.         if (m->key == -1)
  316.             m->key = UNUSED;
  317.         makro_rec_ptr = NULL;
  318.     }
  319.     new = -1;
  320.     m = makro_list;
  321.     for (i=0; i<MAKRO_MAX; i++,m++)            /* Eintrag suchen */
  322.     {
  323.         if (m->mode==UNUSED)                        /* Leerer Eintrag */
  324.             new = i;
  325.     }
  326.     if (new>-1)                                        /* Gefunden */
  327.     {
  328.         m = &makro_list[new];
  329.         makro_rec = TRUE;                            /* Zeichen erfassen */
  330.         makro_rec_ptr = m;
  331.         m->len = 0;                                    /* leeren */
  332.         m->key = -1;
  333.         m->name[0] = EOS;
  334.         print_headline(" Makro-Rec ");
  335.         menu_text(menu, MSRECORD, STRING(MSTOPSTR));
  336.     }
  337. }
  338.  
  339. VOID end_rec(BOOLEAN one_more)
  340. {
  341.     WORD len = makro_rec_ptr->len;
  342.  
  343.     makro_rec = FALSE;
  344.     if (len>1)
  345.     {
  346.         if (one_more)
  347.             makro_rec_ptr->len--;                    /* letztes ^M raus */
  348.         makro_rec_ptr->mode = TASTEN;                /* Makro ist O.K. */
  349.     }
  350.     else
  351.         makro_rec_ptr = NULL;
  352.     print_headline("           ");
  353.     menu_text(menu, MSRECORD, STRING(MRECSTR));
  354. }
  355.  
  356. VOID makro_on_key(UBYTE *name, WORD key)
  357. {
  358.     T_MAKRO    *m;
  359.  
  360.     if (makro_rec_ptr!=NULL)
  361.     {
  362.         del_makro(key);
  363.         m = makro_rec_ptr;
  364.         makro_rec_ptr = NULL;
  365.         m->key = key;
  366.         strcpy(m->name, name);
  367.         set_fkey(key, name);
  368.         draw_fkey(key, FALSE);
  369.     }
  370. }
  371.  
  372. BOOLEAN start_play(WORD key, WORD anz)
  373. {
  374.     WORD        i;
  375.     T_MAKRO    *m;
  376.     BOOLEAN    ret = FALSE;
  377.  
  378.     if (key == -1)                /* aktuelles Makro */
  379.     {
  380.         m = makro_rec_ptr;
  381.         if (m == NULL)
  382.         {
  383.             mybeep();
  384.             return FALSE;
  385.         }
  386.     }
  387.     else                            /* Funktionstaste */
  388.     {
  389.         m = makro_list;
  390.         for (i=0; i<MAKRO_MAX; i++,m++)            /* Eintrag suchen */
  391.             if (m->mode!=UNUSED && m->key==key)
  392.                 break;
  393.         if (i == MAKRO_MAX)
  394.         {
  395.             mybeep();
  396.             return FALSE;
  397.         }
  398.     }
  399.     if (m->mode == TASTEN)                        /* Eintrag gefunden */
  400.     {
  401.         if (!makro_play)                            /* Neues M. starten */
  402.         {
  403.             Arrow_mouse();
  404.             if (m->key>=0)
  405.                 draw_fkey (m->key,TRUE);
  406.             COPYW(makro_puffer, m->daten.puffer, m->len * (short) sizeof(T_KEY));
  407.             makro_end = makro_puffer+m->len;
  408.             makro_ptr = makro_puffer;
  409.             makro_play = TRUE;
  410.             makro_play_ptr = m;
  411.             makro_play_counter = max(1,anz);
  412.             print_headline("Makro-Play ");
  413.             ret = TRUE;
  414.         }
  415.         else                                            /* Makro ruft Makro auf */
  416.         {
  417.             WORD len_old = (short) (makro_end - makro_ptr);
  418.             WORD len_new = m->len;
  419.             if (len_old+len_new < MAKRO_PLAY_LEN)
  420.             {
  421.                 /* Alten Rest nach hinten verschieben */
  422.                 MOVE((UBYTE*)&makro_puffer[len_new],(UBYTE*)makro_ptr,len_old * (short) sizeof(T_KEY));
  423.                 /* Neues Makro einfügen */
  424.                 COPYW(makro_puffer,m->daten.puffer,m->len * (short) sizeof(T_KEY));
  425.                 makro_end = makro_puffer+(len_old+len_new);
  426.                 makro_ptr = makro_puffer;
  427.                 ret = TRUE;
  428.             }
  429.             else
  430.                 mybeep();
  431.         }
  432.     }
  433.     else if(m->mode==BLOCK && !makro_rec && !makro_play)
  434.     {
  435.         RING t;
  436.  
  437.         draw_fkey(m->key, TRUE);
  438.         init_textring(&t);
  439.         doppeln(&m->daten.text,&t);
  440.         clip_takes_text(&t);
  441.         do_action(DO_PASTE);
  442.         draw_fkey(m->key, FALSE);
  443.         ret = TRUE;
  444.     }
  445.     else                                                /* Kein Eintrag gefunden */
  446.         mybeep();
  447.     return ret;
  448. }
  449.  
  450. VOID end_play(VOID)
  451. {
  452.     T_MAKRO *m;
  453.  
  454.     if (makro_play)
  455.     {
  456.         m = makro_play_ptr;
  457.         if (m->key>=0)
  458.             draw_fkey (m->key,FALSE);
  459.         makro_play = FALSE;
  460.         makro_play_ptr = NULL;
  461.         print_headline("           ");
  462.     }
  463. }
  464.  
  465. VOID init_makro(VOID)
  466. {
  467.     WORD i;
  468.     T_MAKRO *m;
  469.  
  470.     makro_play = makro_rec = FALSE;
  471.     for (i=MAKRO_MAX,m=makro_list; (--i)>=0; m++)
  472.         m->mode = UNUSED;
  473. }
  474.  
  475.  
  476. /***************************************************************************/
  477. /* Dialog ******************************************************************/
  478. /***************************************************************************/
  479.  
  480. LOCAL VOID show_makro(WORD nr)
  481. /* 0..19 */
  482. {
  483.     UBYTE    name[9];
  484.  
  485.     if (nr < 10)
  486.         get_makro_name(0x3B00 + (nr * 0x100), name);
  487.     else
  488.         get_makro_name(0x5400 + ((nr - 10) * 0x100), name);
  489.  
  490.     objc_setstring(funktionstasten, FNNAME, name);
  491.     draw_Objc(funktionstasten, FNNAME, 1);
  492.  
  493.     disable_objc(funktionstasten, FNDELETE, (name[0] == EOS));
  494.     draw_Objc(funktionstasten, FNDELETE, 1);
  495. }
  496.  
  497. VOID makro_dial(VOID)
  498. {
  499.     WORD        antw, y, edobj;
  500.     UBYTE        name[9];
  501.     TEXTP     t_ptr;
  502.     DIALINFO    dial;
  503.     BOOLEAN    quit = FALSE;
  504.     WORD        makro_nr = 0;
  505.  
  506.     do_icon(iclipbrd, DO_UPDATE);
  507.     t_ptr = get_text(iclipbrd);
  508.     disable_objc(funktionstasten, FNBLOCK, ist_leer(&t_ptr->text));
  509.     objc_setstring(funktionstasten, FNNAME, "");
  510.     objc_setstring(funktionstasten, FNKEY, " F1");
  511.     Arrow_mouse();
  512.     open_dial(funktionstasten, FALSE, NULL, &dial);
  513.     dial_draw(&dial);
  514.     show_makro(makro_nr);
  515.     edobj = FNNAME;
  516.     do
  517.     {
  518.         antw = dial_do(&dial, &edobj) & 0x7FFF;
  519.         switch (antw)
  520.         {
  521.             case FNSTR :
  522.             case FNCIRCLE :
  523.             case FNKEY :
  524.                 if (antw == FNCIRCLE)
  525.                     y = popup_select(NIL, funktionstasten, FNKEY, popups, FUNCPOP, FALSE, DO_CYCLE, NULL, (POP_CB)NULL);
  526.                 else
  527.                     y = popup_select(NIL, funktionstasten, FNKEY, popups, FUNCPOP, FALSE, DO_POPUP, NULL, (POP_CB)NULL);
  528.                 y -= POPF1;
  529.                 if (y >= 0)
  530.                 {
  531.                     makro_nr = y;
  532.                     show_makro(makro_nr);
  533.                 }
  534.                 break;
  535.             case FNDELETE:
  536.                 if (makro_nr < 10)
  537.                     del_makro(0x3B00 + (makro_nr * 0x100));
  538.                 else
  539.                     del_makro(0x5400 + ((makro_nr - 10) * 0x100));
  540.                 show_makro(makro_nr);
  541.                 select_objc(funktionstasten, antw, FALSE);
  542.                 draw_Objc(funktionstasten, antw, 1);
  543.                 break;
  544.             case FNRECORD:
  545.             case FNBLOCK:
  546.                 objc_getstring(funktionstasten, FNNAME, name);
  547.                 select_objc(funktionstasten, antw, FALSE);
  548.                 draw_Objc(funktionstasten, antw, 1);
  549.                 if (*name == EOS)
  550.                     note(1, MKNAME);
  551.                 else
  552.                     quit = TRUE;
  553.                 break;
  554.             default:
  555.                 quit = TRUE;
  556.                 break;
  557.         }
  558.     }
  559.     while (!quit);
  560.     select_objc(funktionstasten, antw, FALSE);
  561.     dial_end(&dial);
  562.     Last_mouse();
  563.     if (antw == FNRECORD)
  564.     {
  565.         if (makro_nr < 10)
  566.             makro_on_key(name, 0x3B00 + (makro_nr * 0x100));
  567.         else
  568.             makro_on_key(name, 0x5400 + ((makro_nr - 10) * 0x100) );
  569.     }
  570.     if (antw == FNBLOCK)
  571.     {
  572.         if (makro_nr < 10)
  573.             start_blk_rec(name, 0x3B00 + (makro_nr * 0x100), &t_ptr->text);
  574.         else
  575.             start_blk_rec(name, 0x5400 + ((makro_nr - 10) * 0x100), &t_ptr->text);
  576.     }
  577. }
  578.